package tools;

import game.Configurations;
import game.Game;
import game.Data;
import game.Data.BlocoInfo;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import math.Point;
import org.lwjgl.input.Keyboard;
import org.lwjgl.input.Mouse;
import org.lwjgl.opengl.Display;
import saves.Area;
import saves.BlocoSimples;
import saves.objects.ElementoCircuito;
import saves.objects.SeletorBloco;

public class AreaEditor extends JFrame {

    private static final long serialVersionUID = -6455497434969872147L;
    public static final int[][] MATRIZ_PADRAO = {{0, 1, 1, 1, 0}, {0, 1, 1, 1, 0}, {0, 0, 1, 1, 0}, {0, 0, 0, 1, 0}, {0, 0, 0, 0, 0}};
    public static final Font FONTE_PADRAO = new Font("Arial", 0, 12);
    
    private LButton[] botoes;
    private int largura, altura;
    private AreaDesenho desenho;
    private SeletorBlocos seletor;
    private int operacaoAtual, tipoAtual, abaAtual, posSeletorArea;
    private Area area;
    private boolean editando;

    public static void main(String[] args) {
        Game.loadConfigs();
        AreaEditor a = new AreaEditor();

        try {
            Display.setParent(a.desenho);
        } catch (Exception e) {
            System.err.println("Couldn't create the drawing panel.");
            System.exit(1); 
        }
        Game.initGL(a.desenho.d.width, a.desenho.d.height);
        Game.loadImages();
        
        Mouse.destroy();
        Keyboard.destroy();

        while (a.isVisible()) {
            if (a.area != null)
                a.area.desenhar(null);
            Display.update();
            Display.sync(60);
        }

        Display.destroy();
        a.dispose();
    }

    public AreaEditor() {
        super("Area Editor");
        this.setSize(600, 480);
        this.setExtendedState(JFrame.MAXIMIZED_BOTH);
        this.setDefaultCloseOperation(DISPOSE_ON_CLOSE);

        JPanel barraSuperior = new JPanel();
        barraSuperior.setLayout(new FlowLayout());
        botoes = new LButton[9];
        operacaoAtual = 5;
        editando = true;
        tipoAtual = 0;
        abaAtual = 0;
        botoes[0] = new LButton("new", 1, "Create a new area");
        botoes[1] = new LButton("open", 2, "Open a saved area");
        botoes[2] = new LButton("save", 3, "Save the current area");
        botoes[3] = new LButton("edit", 4, "Edit current area's information");
        botoes[4] = new LButton("cursor", 5, "Select and edit the blocks");
        botoes[5] = new LButton("pencil", 6, "Edit the information about the blocks");
        botoes[6] = new LButton("lineto", 7, "Create a circuit path between two blocks");
        botoes[7] = new LButton("delete", 8, "Delete all circuits within an area");
        botoes[8] = new LButton("linedel", 9, "Delete all circuits in a line between two blocks");
        for (int i = 0; i < botoes.length; i++)
            barraSuperior.add(botoes[i]);

        verificarBotoes();

        desenho = new AreaDesenho();
        seletor = new SeletorBlocos();

        this.setLayout(new BorderLayout());
        this.add(barraSuperior, BorderLayout.PAGE_START);
        this.add(desenho, BorderLayout.CENTER);
        this.add(seletor, BorderLayout.LINE_END);

        this.setVisible(true);

        Data.load();        
        largura = desenho.getWidth();
        altura = desenho.getWidth();
        area = new Area(MATRIZ_PADRAO, largura, altura);
        area.addObjeto(new SeletorBloco(0, 0, Color.RED));
        area.setReferencia();
        area.addObjeto(new SeletorBloco(0, 0, Color.BLUE, false));
        area.addObjeto(new SeletorBloco(0, 0, Color.GREEN, false));
        posSeletorArea = 0;

        this.setDefaultCloseOperation(HIDE_ON_CLOSE);

        this.setFocusable(false);
        KeyboardFocusManager.getCurrentKeyboardFocusManager().addKeyEventDispatcher(new KeyEventDispatcher() {

            @Override
            public boolean dispatchKeyEvent(KeyEvent e) {
                if (e.getID() == KeyEvent.KEY_PRESSED && editando) {
                    int code = e.getKeyCode();
                    SeletorBloco s = (SeletorBloco) area.getObjeto(posSeletorArea);
                    switch (code) {
                        case KeyEvent.VK_LEFT:
                            if (area.contem(s.getPixelX() - 1, s.getPixelY())) {
                                s.mover(-1, 0);
                                area.recalcularDelta(0);
                                redesenhar();
                            }
                            break;
                        case KeyEvent.VK_RIGHT:
                            if (area.contem(s.getPixelX() + 1, s.getPixelY())) {
                                s.mover(1, 0);
                                area.recalcularDelta(0);
                                redesenhar();
                            }
                            break;
                        case KeyEvent.VK_UP:
                            if (area.contem(s.getPixelX(), s.getPixelY() - 1)) {
                                s.mover(0, -1);
                                area.recalcularDelta(0);
                                redesenhar();
                            }
                            break;
                        case KeyEvent.VK_DOWN:
                            if (area.contem(s.getPixelX(), s.getPixelY() + 1)) {
                                s.mover(0, 1);
                                area.recalcularDelta(0);
                                redesenhar();
                            }
                            area.recalcularDelta(0);
                            redesenhar();
                            break;
                        case KeyEvent.VK_1:
                            tipoAtual = 0;
                            redesenhar();
                            break;
                        case KeyEvent.VK_2:
                            tipoAtual = 1;
                            redesenhar();
                            break;
                        case KeyEvent.VK_3:
                            tipoAtual = 2;
                            redesenhar();
                            break;
                        case KeyEvent.VK_4:
                            tipoAtual = 3;
                            redesenhar();
                            break;
                        case KeyEvent.VK_5:
                            tipoAtual = 4;
                            redesenhar();
                            break;
                        case KeyEvent.VK_6:
                            tipoAtual = 5;
                            redesenhar();
                            break;
                        case KeyEvent.VK_7:
                            tipoAtual = 6;
                            redesenhar();
                            break;
                        case KeyEvent.VK_8:
                            tipoAtual = 7;
                            redesenhar();
                            break;
                        case KeyEvent.VK_9:
                            tipoAtual = 8;
                            redesenhar();
                            break;
                        case KeyEvent.VK_SPACE:
                            area.setBloco(s.getPixelX() / Configurations.BLOCK_SIZE, s.getPixelY() / Configurations.BLOCK_SIZE, tipoAtual);
                            redesenhar();
                            break;
                        case KeyEvent.VK_A:
                            boolean[] dir = new boolean[4];
                            dir[0] = true;
                            dir[1] = false;
                            dir[2] = false;
                            dir[3] = false;
                            area.addObjeto(new ElementoCircuito(20, 20, tipoAtual, dir, area.getWorld()));
                            redesenhar();
                            break;
                        case KeyEvent.VK_C:
                            SeletorBloco b = (SeletorBloco) (area.getObjeto(posSeletorArea + 1));
                            if (b.isVisivel()) {
                                int xIni = (int) (b.getPontoInicial().x / 16),
                                        xFim = (int) (b.getPontoFinal().x / 16),
                                        yIni = (int) (b.getPontoInicial().y / 16),
                                        yFim = (int) (b.getPontoFinal().y / 16);
                                if (xIni > xFim) {
                                    int aux = xFim;
                                    xFim = xIni;
                                    xIni = aux;
                                }
                                if (yIni > yFim) {
                                    int aux = yFim;
                                    yFim = yIni;
                                    yIni = aux;
                                }
                                for (int i = xIni; i < xFim; i++)
                                    for (int j = yIni; j < yFim; j++)
                                        area.setBloco(i, j, tipoAtual);
                                redesenhar();
                            }
                            break;
                    }
                }
                return false;
            }
        });
    }

    private class SeletorBlocos extends JPanel {

        private static final long serialVersionUID = 3676754394163336388L;
        private Dimension d;
        private int inicio, w;

        public SeletorBlocos() {
            super();
            d = new Dimension(AreaEditor.this.getWidth() / 4, AreaEditor.this.getHeight());
            this.setPreferredSize(d);
            this.setMinimumSize(d);
            this.inicio = 35;
            this.w = ((int) d.getWidth() - 25) / 2;

            this.addMouseListener(new MouseAdapter() {

                @Override
                public void mousePressed(MouseEvent e) {
                    if (e.getY() < inicio) {
                        if (e.getY() > 10)
                            if (e.getX() > 10 && e.getX() < w + 10) {
                                abaAtual = 0;
                                tipoAtual = 0;
                                redesenhar();
                            } else if (e.getX() >= w + 15 && e.getX() <= ((int) d.getWidth()) - 25) {
                                abaAtual = 1;
                                tipoAtual = 0;
                                redesenhar();
                            }
                    } else if (abaAtual == 0) {
                        if (e.getX() >= 10 && e.getX() <= d.getWidth() - 20 && ((e.getY() - inicio) % 30 <= 26)) {
                            int t = (e.getY() - inicio) / 30;
                            if (t < Data.qtosBlocos()) {
                                tipoAtual = t;
                                redesenhar();
                            }
                        }
                    } else if (abaAtual == 1)
                        if (e.getX() >= 10 && e.getX() <= d.getWidth() - 20 && ((e.getY() - inicio) % 30 <= 26)) {
                            int t = (e.getY() - inicio) / 30;
                            if (t <= ElementoCircuito.MAX_TIPO) {
                                tipoAtual = t;
                                redesenhar();
                            }
                        }
                }
            });
        }

        @Override
        public void paint(Graphics g) {
            g.setColor(Color.DARK_GRAY);
            g.fillRect(0, 0, getWidth(), getHeight());
            BlocoInfo[] blocos = Data.getBlocos().toArray(new BlocoInfo[Data.getBlocos().size()]);
            g.setFont(FONTE_PADRAO);
            //Desenhar abas
            if (abaAtual == 0)
                g.setColor(Color.RED);
            else
                g.setColor(Color.LIGHT_GRAY);
            g.fillRect(10, 10, w, 20);
            if (abaAtual == 1)
                g.setColor(Color.RED);
            else
                g.setColor(Color.LIGHT_GRAY);
            g.fillRect(15 + w, 10, w, 20);
            g.setColor(Color.BLUE);
            g.drawString("Blocos", 15, 25);
            g.drawString("Objetos", 20 + w, 25);
            if (abaAtual == 0)
                //Desenhar aba 0
                for (int i = 0; i < blocos.length; i++) {
                    if (i == tipoAtual)
                        g.setColor(Color.RED);
                    else
                        g.setColor(Color.BLUE);
                    g.fillRect(10, inicio + 30 * i, (int) d.getWidth() - 20, 26);
                    g.setColor(Color.WHITE);
                    //g.drawImage(((Imagem.AWT) BlockLoader.getImagem(i)).imagem, 15, inicio + 5 + 30 * i, null);
                    g.drawString(blocos[i].getNome(), 35, inicio + 17 + 30 * i);
                }
            else if (abaAtual == 1)
                //Desenhar aba 1
                //Desenhar ElementoCircuitos
                for (int i = 0; i < ElementoCircuito.MAX_TIPO; i++) {
                    if (i == tipoAtual)
                        g.setColor(Color.RED);
                    else
                        g.setColor(Color.BLUE);
                    g.fillRect(10, inicio + 30 * i, (int) d.getWidth() - 20, 26);
                    g.setColor(Color.WHITE);
                    //g.drawImage(((Imagem.AWT) Carregador.getImagem(ElementoCircuito.getImagem(i)[0])).imagem, 15, inicio + 5 + 30 * i, 16, 16, null);
                    g.drawString(ElementoCircuito.getNome(i), 35, inicio + 17 + 30 * i);
                }
        }
    }

    private class MouseDesenho implements MouseListener, MouseMotionListener {

        private boolean arrastando;

        public MouseDesenho() {
            this.arrastando = false;
        }

        @Override
        public void mousePressed(MouseEvent e) {
            System.out.println("Pressed mouse!");
            int x = 16 * (int) (area.desconverterX(e.getX()) / 16);
            int y = 16 * (int) (area.desconverterY(e.getY()) / 16);
            if (e.getButton() == MouseEvent.BUTTON3) {
                if (area.contem(x, y)) {
                    //((SeletorBloco) area.getObjeto(posSeletorArea)).setX(x);
                    //((SeletorBloco) area.getObjeto(posSeletorArea)).setY(y);
                }
                redesenhar();
                return;
            } else if (e.getButton() == MouseEvent.BUTTON2) {
                area.setObjeto(1, new SeletorBloco(0, 0, Color.BLUE, false));
                redesenhar();
                return;
            }

            if (operacaoAtual == 5) {
                area.setObjeto(1, new SeletorBloco(x, y, Color.BLUE));
                arrastando = true;
                redesenhar();
            } else if (operacaoAtual == 6) {
                area.setObjeto(2, new SeletorBloco(x, y, Color.GREEN));
                redesenhar();
                BlocoSimples b = area.getBlocoSimples(x / 16, y / 16);
                if (b instanceof BlocoSimples.Complexo) {
                    BlocoSimples.Complexo bx = (BlocoSimples.Complexo) b;
                    EditarConexoes ed = new EditarConexoes(bx.getConexoes());
                    if (ed.isOK()) {
                        bx.setConexoes(ed.getConexoes());
                        redesenhar();
                    }
                } else
                    JOptionPane.showMessageDialog(AreaEditor.this, "O bloco selecionado n�o comporta qualquer informa��o adicional.", "Aviso", 2);
            } else if (operacaoAtual == 7) {
                int xBI = area.getObjeto(posSeletorArea).getPixelX() / 16;
                int yBI = area.getObjeto(posSeletorArea).getPixelY() / 16;
                int xBF = x / 16;
                int yBF = y / 16;
                if (xBI == xBF) {
                    if (yBI == yBF) {
                        JOptionPane.showMessageDialog(AreaEditor.this, "Voc� n�o pode ligar um bloco a ele mesmo.", "Aviso", 2);
                        return;
                    }
                    if (yBI > yBF) {
                        int aux = yBI;
                        yBI = yBF;
                        yBF = aux;
                    }
                    boolean c = true;
                    for (int i = yBI; i <= yBF; i++)
                        if (!(area.getBlocoSimples(xBF, i) instanceof BlocoSimples.Complexo))
                            c = false;
                    if (c) {
                        ((BlocoSimples.Complexo) (area.getBlocoSimples(xBF, yBI))).setConexao(2, true);
                        for (int i = yBI + 1; i < yBF; i++) {
                            BlocoSimples.Complexo b = (BlocoSimples.Complexo) (area.getBlocoSimples(xBF, i));
                            b.setConexao(0, true);
                            b.setConexao(2, true);
                        }
                        ((BlocoSimples.Complexo) (area.getBlocoSimples(xBF, yBF))).setConexao(0, true);
                    } else
                        JOptionPane.showMessageDialog(AreaEditor.this, "N�o � poss�vel ligar os dois blocos. � necess�rio haver uma linha reta, desobstru�da e paralela a um dos eixos entre eles.", "Aviso", 2);
                } else if (yBI == yBF) {
                    if (xBI == xBF) {
                        JOptionPane.showMessageDialog(AreaEditor.this, "Voc� n�o pode ligar um bloco a ele mesmo.", "Aviso", 2);
                        return;
                    }
                    if (xBI > xBF) {
                        int aux = xBI;
                        xBI = xBF;
                        xBF = aux;
                    }
                    boolean c = true;
                    for (int i = xBI; i <= xBF; i++)
                        if (!(area.getBlocoSimples(i, yBI) instanceof BlocoSimples.Complexo))
                            c = false;
                    if (c) {
                        ((BlocoSimples.Complexo) (area.getBlocoSimples(xBI, yBF))).setConexao(1, true);
                        for (int i = xBI + 1; i < xBF; i++) {
                            BlocoSimples.Complexo b = (BlocoSimples.Complexo) (area.getBlocoSimples(i, yBF));
                            b.setConexao(1, true);
                            b.setConexao(3, true);
                        }
                        ((BlocoSimples.Complexo) (area.getBlocoSimples(xBF, yBF))).setConexao(3, true);
                    } else
                        JOptionPane.showMessageDialog(AreaEditor.this, "N�o � poss�vel ligar os dois blocos. � necess�rio haver uma linha reta, desobstru�da e paralela a um dos eixos entre eles.", "Aviso", 2);
                } else
                    JOptionPane.showMessageDialog(AreaEditor.this, "N�o � poss�vel ligar os dois blocos. � necess�rio haver uma linha reta, desobstru�da e paralela a um dos eixos entre eles.", "Aviso", 2);
                redesenhar();
            } else if (operacaoAtual == 8) {
                int xBI = area.getObjeto(posSeletorArea).getPixelX() / 16;
                int yBI = area.getObjeto(posSeletorArea).getPixelY() / 16;
                int xBF = x / 16;
                int yBF = y / 16;
                if (yBI > yBF) {
                    int aux = yBI;
                    yBI = yBF;
                    yBF = aux;
                }
                if (xBI > xBF) {
                    int aux = xBI;
                    xBI = xBF;
                    xBF = aux;
                }
                for (int i = xBI; i <= xBF; i++)
                    for (int j = yBI; j <= yBF; j++)
                        if (area.getBlocoSimples(i, j) instanceof BlocoSimples.Complexo) {
                            BlocoSimples.Complexo b = (BlocoSimples.Complexo) (area.getBlocoSimples(i, j));
                            b.setConexao(0, false);
                            b.setConexao(1, false);
                            b.setConexao(2, false);
                            b.setConexao(3, false);
                        }
                redesenhar();
            } else if (operacaoAtual == 9) {
                int xBI = area.getObjeto(posSeletorArea).getPixelX() / 16;
                int yBI = area.getObjeto(posSeletorArea).getPixelY() / 16;
                int xBF = x / 16;
                int yBF = y / 16;
                if (xBI == xBF) {
                    if (yBI > yBF) {
                        int aux = yBI;
                        yBI = yBF;
                        yBF = aux;
                    }
                    if (area.podeTerCircuito(xBF, yBI))
                        ((BlocoSimples.Complexo) (area.getBlocoSimples(xBF, yBI))).setConexao(2, false);
                    for (int i = yBI + 1; i < yBF; i++)
                        if (area.podeTerCircuito(xBF, i)) {
                            BlocoSimples.Complexo b = (BlocoSimples.Complexo) (area.getBlocoSimples(xBF, i));
                            b.setConexao(0, false);
                            b.setConexao(2, false);
                        }
                    if (area.podeTerCircuito(xBF, yBF))
                        ((BlocoSimples.Complexo) (area.getBlocoSimples(xBF, yBF))).setConexao(0, false);
                } else if (yBI == yBF) {
                    if (xBI > xBF) {
                        int aux = xBI;
                        xBI = xBF;
                        xBF = aux;
                    }
                    if (area.podeTerCircuito(xBI, yBF))
                        ((BlocoSimples.Complexo) (area.getBlocoSimples(xBI, yBF))).setConexao(1, false);
                    for (int i = xBI + 1; i < xBF; i++)
                        if (area.podeTerCircuito(i, yBF)) {
                            BlocoSimples.Complexo b = (BlocoSimples.Complexo) (area.getBlocoSimples(i, yBF));
                            b.setConexao(1, false);
                            b.setConexao(3, false);
                        }
                    if (area.podeTerCircuito(xBF, yBF))
                        ((BlocoSimples.Complexo) (area.getBlocoSimples(xBF, yBF))).setConexao(3, false);
                } else
                    JOptionPane.showMessageDialog(AreaEditor.this, "N�o � poss�vel ligar os dois blocos. � necess�rio haver uma linha reta paralela a um dos eixos entre eles.", "Aviso", 2);
                redesenhar();
            }
        }

        @Override
        public void mouseReleased(MouseEvent e) {
            if (arrastando) {
                SeletorBloco b = (SeletorBloco) (area.getObjeto(posSeletorArea + 1));
                b.setPontoFinal(new Point(16 * (int) Math.ceil(area.desconverterX(e.getX()) / 16), 16 * (int) Math.ceil(area.desconverterY(e.getY()) / 16)));
                redesenhar();
                arrastando = false;
            }
        }

        @Override
        public void mouseDragged(MouseEvent e) {
            if (arrastando) {
                SeletorBloco b = (SeletorBloco) (area.getObjeto(posSeletorArea + 1));
                b.setPontoFinal(new Point(16 * (int) Math.ceil(area.desconverterX(e.getX()) / 16), 16 * (int) Math.ceil(area.desconverterY(e.getY()) / 16)));
                redesenhar();
            }
        }

        @Override
        public void mouseClicked(MouseEvent e) {
        }

        @Override
        public void mouseEntered(MouseEvent e) {
        }

        @Override
        public void mouseExited(MouseEvent e) {
        }

        @Override
        public void mouseMoved(MouseEvent e) {
        }
    }

    private class AreaDesenho extends Canvas {

        private static final long serialVersionUID = 194264301540075519L;
        private Dimension d;

        public AreaDesenho() {
            d = new Dimension(3 * AreaEditor.this.getWidth() / 4, AreaEditor.this.getHeight());
            this.setPreferredSize(d);
            this.setMinimumSize(d);

            this.setFocusable(false);
            MouseDesenho m = new MouseDesenho();
            this.addMouseListener(m);
            this.addMouseMotionListener(m);
        }

        @Override
        public int getWidth() {
            return (int) d.getWidth();
        }

        @Override
        public int getHeight() {
            return (int) d.getHeight();
        }
    }

    public int[][] gerarMatrizLimpa(int largura, int altura) {
        int[][] r = new int[largura][altura];
        for (int i = 0; i < largura; i++)
            for (int j = 0; j < altura; j++)
                r[i][j] = 0;
        return r;
    }

    public void redesenhar() {
        seletor.repaint();
    }

    public final void verificarBotoes() {
        for (int i = 0; i < botoes.length; i++)
            botoes[i].verificar();
    }

    private class LButton extends JButton implements ActionListener {

        private static final long serialVersionUID = -1955066957251515961L;
        protected int btnStatus;
        protected boolean up, ativo;

        public LButton(String img, int btnStatus, String tooltip) {
            super(new ImageIcon("tools//" + img + ".png"));

            this.setToolTipText(tooltip);
            this.setFocusable(false);
            this.btnStatus = btnStatus;
            this.up = false;
            this.ativo = true;

            this.setBorder(null);
            this.addActionListener(this);
        }

        @Override
        public void paintComponent(Graphics g) {
            this.setBackground(Color.LIGHT_GRAY);
            this.setEnabled(ativo);
            if (up)
                this.setBorder(BorderFactory.createEtchedBorder());
            else
                this.setBorder(null);
            super.paintComponent(g);
        }

        public void setUp(boolean b) {
            this.up = b;
        }

        public void verificar() {
            this.setUp(operacaoAtual == btnStatus);

        }

        @Override
        public void actionPerformed(ActionEvent e) {
            area.setObjeto(2, new SeletorBloco(0, 0, Color.GREEN, false));
            switch (btnStatus) {
                case 1: //Novo
                    editando = false;
                    area = new Area(gerarMatrizLimpa(Integer.parseInt(JOptionPane.showInputDialog(null, "Escolha a largura.", "AreaEditor", 1)), Integer.parseInt(JOptionPane.showInputDialog(null, "Escolha a altura.", "AreaEditor", 1))), largura, altura);
                    area.addObjeto(new SeletorBloco(0, 0, Color.RED));
                    area.setReferencia();
                    area.addObjeto(new SeletorBloco(0, 0, Color.BLUE, false));
                    area.addObjeto(new SeletorBloco(0, 0, Color.GREEN, false));
                    editando = true;
                    break;
                case 2: //Abrir
                    editando = false;
                    JFileChooser o = new JFileChooser();
                    if (o.showOpenDialog(AreaEditor.this) == JFileChooser.APPROVE_OPTION)
                        try {
                            area = Area.carregarArea(o.getSelectedFile().getAbsolutePath());
                            posSeletorArea = area.qtosObjetos();
                            area.addObjeto(new SeletorBloco(0, 0, Color.RED));
                            area.addObjeto(new SeletorBloco(0, 0, Color.BLUE, false));
                            area.addObjeto(new SeletorBloco(0, 0, Color.GREEN, false));
                        } catch (Exception e1) {
                            JOptionPane.showMessageDialog(AreaEditor.this, "N�o foi poss�vel abrir o arquivo. Erro: " + e1.getMessage(), "Aviso", 2);
                        }
                    editando = true;
                    break;
                case 3: //Salvar
                    editando = false;
                    JFileChooser s = new JFileChooser();
                    if (s.showSaveDialog(AreaEditor.this) == JFileChooser.APPROVE_OPTION)
                        if (!Area.salvarArea(s.getSelectedFile().getAbsolutePath(), area))
                            JOptionPane.showMessageDialog(AreaEditor.this, "N�o foi poss�vel salvar o arquivo.", "Aviso", 2);
                    editando = true;
                    break;
                case 4:
                    break;
                default:
                    operacaoAtual = btnStatus;
                    break;
            }
            verificarBotoes();
            redesenhar();
        }
    }
}
